rgeo 0.4.0 → 0.5.0

data/lib/rgeo/geos/capi_feature_classes.rb

@@ -5,192 +5,125 @@
 # -----------------------------------------------------------------------------
 
 module RGeo
-
   module Geos
-
-
-    module CAPIGeometryMethods  # :nodoc:
-
-
+    module CAPIGeometryMethods # :nodoc:
       include Feature::Instance
 
-
       def inspect
         "#<#{self.class}:0x#{object_id.to_s(16)} #{as_text.inspect}>"
       end
 
-
       # Marshal support
 
-      def marshal_dump  # :nodoc:
-        factory_ = self.factory
+      def marshal_dump # :nodoc:
+        factory_ = factory
         [factory_, factory_._write_for_marshal(self)]
       end
 
-      def marshal_load(data_)  # :nodoc:
+      def marshal_load(data_) # :nodoc:
         obj_ = data_[0]._read_for_marshal(data_[1])
         _steal(obj_)
       end
 
-
       # Psych support
 
-      def encode_with(coder_)  # :nodoc:
-        factory_ = self.factory
-        coder_['factory'] = factory_
+      def encode_with(coder_) # :nodoc:
+        factory_ = factory
+        coder_["factory"] = factory_
         str_ = factory_._write_for_psych(self)
-        str_ = str_.encode('US-ASCII') if str_.respond_to?(:encode)
-        coder_['wkt'] = str_
+        str_ = str_.encode("US-ASCII") if str_.respond_to?(:encode)
+        coder_["wkt"] = str_
       end
 
-      def init_with(coder_)  # :nodoc:
-        obj_ = coder_['factory']._read_for_psych(coder_['wkt'])
+      def init_with(coder_) # :nodoc:
+        obj_ = coder_["factory"]._read_for_psych(coder_["wkt"])
         _steal(obj_)
       end
 
-
       def as_text
         str_ = _as_text
-        str_.force_encoding('US-ASCII') if str_.respond_to?(:force_encoding)
+        str_.force_encoding("US-ASCII") if str_.respond_to?(:force_encoding)
         str_
       end
       alias_method :to_s, :as_text
-
-
     end
 
-
-    module CAPIGeometryCollectionMethods  # :nodoc:
-
+    module CAPIGeometryCollectionMethods # :nodoc:
       include ::Enumerable
-
     end
 
-
-    class CAPIGeometryImpl  # :nodoc:
-
-
+    class CAPIGeometryImpl # :nodoc:
       include CAPIGeometryMethods
 
       Feature::MixinCollection::GLOBAL.for_type(Feature::Geometry).include_in_class(self, true)
-
-
     end
 
-
-    class CAPIPointImpl  # :nodoc:
-
-
+    class CAPIPointImpl # :nodoc:
       include CAPIGeometryMethods
       include CAPIPointMethods
 
       Feature::MixinCollection::GLOBAL.for_type(Feature::Point).include_in_class(self, true)
-
-
     end
 
-
     class CAPILineStringImpl  # :nodoc:
-
-
       include CAPIGeometryMethods
       include CAPILineStringMethods
 
       Feature::MixinCollection::GLOBAL.for_type(Feature::LineString).include_in_class(self, true)
-
-
     end
 
-
     class CAPILinearRingImpl  # :nodoc:
-
-
       include CAPIGeometryMethods
       include CAPILineStringMethods
       include CAPILinearRingMethods
 
       Feature::MixinCollection::GLOBAL.for_type(Feature::LinearRing).include_in_class(self, true)
-
-
     end
 
-
-    class CAPILineImpl  # :nodoc:
-
-
+    class CAPILineImpl # :nodoc:
       include CAPIGeometryMethods
       include CAPILineStringMethods
       include CAPILineMethods
 
       Feature::MixinCollection::GLOBAL.for_type(Feature::Line).include_in_class(self, true)
-
-
     end
 
-
-    class CAPIPolygonImpl  # :nodoc:
-
-
+    class CAPIPolygonImpl # :nodoc:
       include CAPIGeometryMethods
       include CAPIPolygonMethods
 
       Feature::MixinCollection::GLOBAL.for_type(Feature::Polygon).include_in_class(self, true)
-
-
     end
 
-
-    class CAPIGeometryCollectionImpl  # :nodoc:
-
-
+    class CAPIGeometryCollectionImpl # :nodoc:
       include CAPIGeometryMethods
       include CAPIGeometryCollectionMethods
 
       Feature::MixinCollection::GLOBAL.for_type(Feature::GeometryCollection).include_in_class(self, true)
-
-
     end
 
-
-    class CAPIMultiPointImpl  # :nodoc:
-
-
+    class CAPIMultiPointImpl # :nodoc:
       include CAPIGeometryMethods
       include CAPIGeometryCollectionMethods
       include CAPIMultiPointMethods
 
       Feature::MixinCollection::GLOBAL.for_type(Feature::MultiPoint).include_in_class(self, true)
-
-
     end
 
-
-    class CAPIMultiLineStringImpl  # :nodoc:
-
-
+    class CAPIMultiLineStringImpl # :nodoc:
       include CAPIGeometryMethods
       include CAPIGeometryCollectionMethods
       include CAPIMultiLineStringMethods
 
       Feature::MixinCollection::GLOBAL.for_type(Feature::MultiLineString).include_in_class(self, true)
-
-
     end
 
-
-    class CAPIMultiPolygonImpl  # :nodoc:
-
-
+    class CAPIMultiPolygonImpl # :nodoc:
       include CAPIGeometryMethods
       include CAPIGeometryCollectionMethods
       include CAPIMultiPolygonMethods
 
       Feature::MixinCollection::GLOBAL.for_type(Feature::MultiPolygon).include_in_class(self, true)
-
-
     end
-
-
   end
-
 end

data/lib/rgeo/geos/ffi_factory.rb

@@ -5,24 +5,18 @@
 # -----------------------------------------------------------------------------
 
 module RGeo
-
   module Geos
-
-
     # This the FFI-GEOS implementation of ::RGeo::Feature::Factory.
 
     class FFIFactory
-
-
       include Feature::Factory::Instance
 
-
       # Create a new factory. Returns nil if the FFI-GEOS implementation
       # is not supported.
       #
       # See ::RGeo::Geos.factory for a list of supported options.
 
-      def initialize(opts_={})
+      def initialize(opts_ = {})
         # Main flags
         @uses_lenient_multi_polygon_assertions = opts_[:uses_lenient_assertions] ||
           opts_[:lenient_multi_polygon_assertions] || opts_[:uses_lenient_multi_polygon_assertions]
@@ -46,7 +40,7 @@ module RGeo
           @wkt_generator = WKRep::WKTGenerator.new(wkt_generator_)
           @wkt_writer = nil
         else
-          @wkt_generator = WKRep::WKTGenerator.new(:convert_case => :upper)
+          @wkt_generator = WKRep::WKTGenerator.new(convert_case: :upper)
           @wkt_writer = nil
         end
         wkb_generator_ = opts_[:wkb_generator]
@@ -66,15 +60,19 @@ module RGeo
         @srid = opts_[:srid]
         @proj4 = opts_[:proj4]
         if CoordSys::Proj4.supported?
-          if @proj4.kind_of?(::String) || @proj4.kind_of?(::Hash)
+          if @proj4.is_a?(::String) || @proj4.is_a?(::Hash)
             @proj4 = CoordSys::Proj4.create(@proj4)
           end
         else
           @proj4 = nil
         end
         @coord_sys = opts_[:coord_sys]
-        if @coord_sys.kind_of?(::String)
-          @coord_sys = CoordSys::CS.create_from_wkt(@coord_sys) rescue nil
+        if @coord_sys.is_a?(::String)
+          @coord_sys = begin
+                         CoordSys::CS.create_from_wkt(@coord_sys)
+                       rescue
+                         nil
+                       end
         end
         if (!@proj4 || !@coord_sys) && @srid && (db_ = opts_[:srs_database])
           entry_ = db_.get(@srid.to_i)
@@ -113,14 +111,12 @@ module RGeo
         end
       end
 
-
       # Standard object inspection output
 
       def inspect
         "#<#{self.class}:0x#{object_id.to_s(16)} srid=#{srid}>"
       end
 
-
       # Factory equivalence test.
 
       def eql?(rhs_)
@@ -132,129 +128,119 @@ module RGeo
       end
       alias_method :==, :eql?
 
-
       # Standard hash code
 
       def hash
         @hash ||= [@srid, @has_z, @has_m, @buffer_resolution, @proj4].hash
       end
 
-
       # Marshal support
 
-      def marshal_dump  # :nodoc:
+      def marshal_dump # :nodoc:
         hash_ = {
-          'hasz' => @has_z,
-          'hasm' => @has_m,
-          'srid' => @srid,
-          'bufr' => @buffer_resolution,
-          'wktg' => @wkt_generator._properties,
-          'wkbg' => @wkb_generator._properties,
-          'wktp' => @wkt_parser._properties,
-          'wkbp' => @wkb_parser._properties,
-          'lmpa' => @uses_lenient_multi_polygon_assertions,
-          'apre' => @_auto_prepare,
+          "hasz" => @has_z,
+          "hasm" => @has_m,
+          "srid" => @srid,
+          "bufr" => @buffer_resolution,
+          "wktg" => @wkt_generator._properties,
+          "wkbg" => @wkb_generator._properties,
+          "wktp" => @wkt_parser._properties,
+          "wkbp" => @wkb_parser._properties,
+          "lmpa" => @uses_lenient_multi_polygon_assertions,
+          "apre" => @_auto_prepare
         }
-        hash_['proj4'] = @proj4.marshal_dump if @proj4
-        hash_['cs'] = @coord_sys.to_wkt if @coord_sys
+        hash_["proj4"] = @proj4.marshal_dump if @proj4
+        hash_["cs"] = @coord_sys.to_wkt if @coord_sys
         hash_
       end
 
-      def marshal_load(data_)  # :nodoc:
-        if CoordSys::Proj4.supported? && (proj4_data_ = data_['proj4'])
+      def marshal_load(data_) # :nodoc:
+        if CoordSys::Proj4.supported? && (proj4_data_ = data_["proj4"])
           proj4_ = CoordSys::Proj4.allocate
           proj4_.marshal_load(proj4_data_)
         else
           proj4_ = nil
         end
-        if (coord_sys_data_ = data_['cs'])
+        if (coord_sys_data_ = data_["cs"])
           coord_sys_ = CoordSys::CS.create_from_wkt(coord_sys_data_)
         else
           coord_sys_ = nil
         end
         initialize(
-          :has_z_coordinate => data_['hasz'],
-          :has_m_coordinate => data_['hasm'],
-          :srid => data_['srid'],
-          :buffer_resolution => data_['bufr'],
-          :wkt_generator => ImplHelper::Utils.symbolize_hash(data_['wktg']),
-          :wkb_generator => ImplHelper::Utils.symbolize_hash(data_['wkbg']),
-          :wkt_parser => ImplHelper::Utils.symbolize_hash(data_['wktp']),
-          :wkb_parser => ImplHelper::Utils.symbolize_hash(data_['wkbp']),
-          :uses_lenient_multi_polygon_assertions => data_['lmpa'],
-          :auto_prepare => (data_['apre'] ? :simple : :disabled),
-          :proj4 => proj4_,
-          :coord_sys => coord_sys_
+          has_z_coordinate: data_["hasz"],
+          has_m_coordinate: data_["hasm"],
+          srid: data_["srid"],
+          buffer_resolution: data_["bufr"],
+          wkt_generator: ImplHelper::Utils.symbolize_hash(data_["wktg"]),
+          wkb_generator: ImplHelper::Utils.symbolize_hash(data_["wkbg"]),
+          wkt_parser: ImplHelper::Utils.symbolize_hash(data_["wktp"]),
+          wkb_parser: ImplHelper::Utils.symbolize_hash(data_["wkbp"]),
+          uses_lenient_multi_polygon_assertions: data_["lmpa"],
+          auto_prepare: (data_["apre"] ? :simple : :disabled),
+          proj4: proj4_,
+          coord_sys: coord_sys_
         )
       end
 
-
       # Psych support
 
-      def encode_with(coder_)  # :nodoc:
-        coder_['has_z_coordinate'] = @has_z
-        coder_['has_m_coordinate'] = @has_m
-        coder_['srid'] = @srid
-        coder_['buffer_resolution'] = @buffer_resolution
-        coder_['lenient_multi_polygon_assertions'] = @uses_lenient_multi_polygon_assertions
-        coder_['wkt_generator'] = @wkt_generator._properties
-        coder_['wkb_generator'] = @wkb_generator._properties
-        coder_['wkt_parser'] = @wkt_parser._properties
-        coder_['wkb_parser'] = @wkb_parser._properties
-        coder_['auto_prepare'] = @_auto_prepare ? 'simple' : 'disabled'
+      def encode_with(coder_) # :nodoc:
+        coder_["has_z_coordinate"] = @has_z
+        coder_["has_m_coordinate"] = @has_m
+        coder_["srid"] = @srid
+        coder_["buffer_resolution"] = @buffer_resolution
+        coder_["lenient_multi_polygon_assertions"] = @uses_lenient_multi_polygon_assertions
+        coder_["wkt_generator"] = @wkt_generator._properties
+        coder_["wkb_generator"] = @wkb_generator._properties
+        coder_["wkt_parser"] = @wkt_parser._properties
+        coder_["wkb_parser"] = @wkb_parser._properties
+        coder_["auto_prepare"] = @_auto_prepare ? "simple" : "disabled"
         if @proj4
           str_ = @proj4.original_str || @proj4.canonical_str
-          coder_['proj4'] = @proj4.radians? ? {'proj4' => str_, 'radians' => true} : str_
+          coder_["proj4"] = @proj4.radians? ? { "proj4" => str_, "radians" => true } : str_
         end
-        coder_['coord_sys'] = @coord_sys.to_wkt if @coord_sys
+        coder_["coord_sys"] = @coord_sys.to_wkt if @coord_sys
       end
 
-      def init_with(coder_)  # :nodoc:
-        if (proj4_data_ = coder_['proj4'])
+      def init_with(coder_) # :nodoc:
+        if (proj4_data_ = coder_["proj4"])
           if proj4_data_.is_a?(::Hash)
-            proj4_ = CoordSys::Proj4.create(proj4_data_['proj4'], :radians => proj4_data_['radians'])
+            proj4_ = CoordSys::Proj4.create(proj4_data_["proj4"], radians: proj4_data_["radians"])
           else
             proj4_ = CoordSys::Proj4.create(proj4_data_.to_s)
           end
         else
           proj4_ = nil
         end
-        if (coord_sys_data_ = coder_['cs'])
+        if (coord_sys_data_ = coder_["cs"])
           coord_sys_ = CoordSys::CS.create_from_wkt(coord_sys_data_.to_s)
         else
           coord_sys_ = nil
         end
         initialize(
-          :has_z_coordinate => coder_['has_z_coordinate'],
-          :has_m_coordinate => coder_['has_m_coordinate'],
-          :srid => coder_['srid'],
-          :buffer_resolution => coder_['buffer_resolution'],
-          :wkt_generator => ImplHelper::Utils.symbolize_hash(coder_['wkt_generator']),
-          :wkb_generator => ImplHelper::Utils.symbolize_hash(coder_['wkb_generator']),
-          :wkt_parser => ImplHelper::Utils.symbolize_hash(coder_['wkt_parser']),
-          :wkb_parser => ImplHelper::Utils.symbolize_hash(coder_['wkb_parser']),
-          :auto_prepare => coder_['auto_prepare'] == 'disabled' ? :disabled : :simple,
-          :uses_lenient_multi_polygon_assertions => coder_['lenient_multi_polygon_assertions'],
-          :proj4 => proj4_,
-          :coord_sys => coord_sys_
+          has_z_coordinate: coder_["has_z_coordinate"],
+          has_m_coordinate: coder_["has_m_coordinate"],
+          srid: coder_["srid"],
+          buffer_resolution: coder_["buffer_resolution"],
+          wkt_generator: ImplHelper::Utils.symbolize_hash(coder_["wkt_generator"]),
+          wkb_generator: ImplHelper::Utils.symbolize_hash(coder_["wkb_generator"]),
+          wkt_parser: ImplHelper::Utils.symbolize_hash(coder_["wkt_parser"]),
+          wkb_parser: ImplHelper::Utils.symbolize_hash(coder_["wkb_parser"]),
+          auto_prepare: coder_["auto_prepare"] == "disabled" ? :disabled : :simple,
+          uses_lenient_multi_polygon_assertions: coder_["lenient_multi_polygon_assertions"],
+          proj4: proj4_,
+          coord_sys: coord_sys_
         )
       end
 
-
       # Returns the SRID of geometries created by this factory.
 
-      def srid
-        @srid
-      end
-
+      attr_reader :srid
 
       # Returns the resolution used by buffer calculations on geometries
       # created by this factory
 
-      def buffer_resolution
-        @buffer_resolution
-      end
-
+      attr_reader :buffer_resolution
 
       # Returns true if this factory is lenient with MultiPolygon assertions
 
@@ -262,7 +248,6 @@ module RGeo
         @uses_lenient_multi_polygon_assertions
       end
 
-
       # See ::RGeo::Feature::Factory#property
 
       def property(name_)
@@ -279,19 +264,15 @@ module RGeo
           @uses_lenient_multi_polygon_assertions
         when :auto_prepare
           @_auto_prepare ? :simple : :disabled
-        else
-          nil
         end
       end
 
-
       # Create a feature that wraps the given ffi-geos geometry object
 
       def wrap_fg_geom(fg_geom_)
         _wrap_fg_geom(fg_geom_, nil)
       end
 
-
       # See ::RGeo::Feature::Factory#parse_wkt
 
       def parse_wkt(str_)
@@ -302,7 +283,6 @@ module RGeo
         end
       end
 
-
       # See ::RGeo::Feature::Factory#parse_wkb
 
       def parse_wkb(str_)
@@ -313,10 +293,9 @@ module RGeo
         end
       end
 
-
       # See ::RGeo::Feature::Factory#point
 
-      def point(x_, y_, z_=0)
+      def point(x_, y_, z_ = 0)
         cs_ = ::Geos::CoordinateSequence.new(1, 3)
         cs_.set_x(0, x_)
         cs_.set_y(0, y_)
@@ -324,11 +303,10 @@ module RGeo
         FFIPointImpl.new(self, ::Geos::Utils.create_point(cs_), nil)
       end
 
-
       # See ::RGeo::Feature::Factory#line_string
 
       def line_string(points_)
-        points_ = points_.to_a unless points_.kind_of?(::Array)
+        points_ = points_.to_a unless points_.is_a?(::Array)
         size_ = points_.size
         return nil if size_ == 1
         cs_ = ::Geos::CoordinateSequence.new(size_, 3)
@@ -345,7 +323,6 @@ module RGeo
         FFILineStringImpl.new(self, ::Geos::Utils.create_line_string(cs_), nil)
       end
 
-
       # See ::RGeo::Feature::Factory#line
 
       def line(start_, end_)
@@ -366,20 +343,18 @@ module RGeo
         FFILineImpl.new(self, ::Geos::Utils.create_line_string(cs_), nil)
       end
 
-
       # See ::RGeo::Feature::Factory#linear_ring
 
       def linear_ring(points_)
-        points_ = points_.to_a unless points_.kind_of?(::Array)
+        points_ = points_.to_a unless points_.is_a?(::Array)
         fg_geom_ = _create_fg_linear_ring(points_)
         fg_geom_ ? FFILinearRingImpl.new(self, fg_geom_, nil) : nil
       end
 
-
       # See ::RGeo::Feature::Factory#polygon
 
-      def polygon(outer_ring_, inner_rings_=nil)
-        inner_rings_ = inner_rings_.to_a unless inner_rings_.kind_of?(::Array)
+      def polygon(outer_ring_, inner_rings_ = nil)
+        inner_rings_ = inner_rings_.to_a unless inner_rings_.is_a?(::Array)
         return nil unless ::RGeo::Feature::LineString.check_type(outer_ring_)
         outer_ring_ = _create_fg_linear_ring(outer_ring_.points)
         inner_rings_ = inner_rings_.map do |r_|
@@ -391,11 +366,10 @@ module RGeo
         fg_geom_ ? FFIPolygonImpl.new(self, fg_geom_, nil) : nil
       end
 
-
       # See ::RGeo::Feature::Factory#collection
 
       def collection(elems_)
-        elems_ = elems_.to_a unless elems_.kind_of?(::Array)
+        elems_ = elems_.to_a unless elems_.is_a?(::Array)
         klasses_ = []
         fg_geoms_ = []
         elems_.each do |elem_|
@@ -411,11 +385,10 @@ module RGeo
         fg_geom_ ? FFIGeometryCollectionImpl.new(self, fg_geom_, klasses_) : nil
       end
 
-
       # See ::RGeo::Feature::Factory#multi_point
 
       def multi_point(elems_)
-        elems_ = elems_.to_a unless elems_.kind_of?(::Array)
+        elems_ = elems_.to_a unless elems_.is_a?(::Array)
         elems_ = elems_.map do |elem_|
           elem_ = ::RGeo::Feature.cast(elem_, self, ::RGeo::Feature::Point,
             :force_new, :keep_subtype)
@@ -428,11 +401,10 @@ module RGeo
         fg_geom_ ? FFIMultiPointImpl.new(self, fg_geom_, klasses_) : nil
       end
 
-
       # See ::RGeo::Feature::Factory#multi_line_string
 
       def multi_line_string(elems_)
-        elems_ = elems_.to_a unless elems_.kind_of?(::Array)
+        elems_ = elems_.to_a unless elems_.is_a?(::Array)
         klasses_ = []
         elems_ = elems_.map do |elem_|
           elem_ = ::RGeo::Feature.cast(elem_, self, ::RGeo::Feature::LineString,
@@ -446,11 +418,10 @@ module RGeo
         fg_geom_ ? FFIMultiLineStringImpl.new(self, fg_geom_, klasses_) : nil
       end
 
-
       # See ::RGeo::Feature::Factory#multi_polygon
 
       def multi_polygon(elems_)
-        elems_ = elems_.to_a unless elems_.kind_of?(::Array)
+        elems_ = elems_.to_a unless elems_.is_a?(::Array)
         elems_ = elems_.map do |elem_|
           elem_ = ::RGeo::Feature.cast(elem_, self, ::RGeo::Feature::Polygon,
             :force_new, :keep_subtype)
@@ -473,34 +444,25 @@ module RGeo
         fg_geom_ ? FFIMultiPolygonImpl.new(self, fg_geom_, klasses_) : nil
       end
 
-
       # See ::RGeo::Feature::Factory#proj4
 
-      def proj4
-        @proj4
-      end
-
+      attr_reader :proj4
 
       # See ::RGeo::Feature::Factory#coord_sys
 
-      def coord_sys
-        @coord_sys
-      end
-
+      attr_reader :coord_sys
 
       # See ::RGeo::Feature::Factory#override_cast
 
-      def override_cast(original_, ntype_, flags_)
+      def override_cast(_original_, _ntype_, _flags_)
         false
         # TODO
       end
 
+      attr_reader :_has_3d # :nodoc:
+      attr_reader :_auto_prepare # :nodoc:
 
-      attr_reader :_has_3d  # :nodoc:
-      attr_reader :_auto_prepare  # :nodoc:
-
-
-      def _wrap_fg_geom(fg_geom_, klass_)  # :nodoc:
+      def _wrap_fg_geom(fg_geom_, klass_) # :nodoc:
         klasses_ = nil
 
         # We don't allow "empty" points, so replace such objects with
@@ -510,7 +472,7 @@ module RGeo
           klass_ = FFIGeometryCollectionImpl
         end
 
-        unless klass_.kind_of?(::Class)
+        unless klass_.is_a?(::Class)
           is_collection_ = false
           case fg_geom_.type_id
           when ::Geos::GeomTypes::GEOS_POINT
@@ -536,16 +498,13 @@ module RGeo
           else
             inferred_klass_ = FFIGeometryImpl
           end
-          if is_collection_ && klass_.is_a?(::Array)
-            klasses_ = klass_
-          end
+          klasses_ = klass_ if is_collection_ && klass_.is_a?(::Array)
           klass_ = inferred_klass_
         end
         klass_.new(self, fg_geom_, klasses_)
       end
 
-
-      def _convert_to_fg_geometry(obj_, type_=nil)  # :nodoc:
+      def _convert_to_fg_geometry(obj_, type_ = nil) # :nodoc:
         if type_.nil? && obj_.factory == self
           obj_
         else
@@ -554,12 +513,11 @@ module RGeo
         obj_ ? obj_.fg_geom : nil
       end
 
-
-      def _create_fg_linear_ring(points_)  # :nodoc:
+      def _create_fg_linear_ring(points_) # :nodoc:
         size_ = points_.size
         return nil if size_ == 1 || size_ == 2
         if size_ > 0 && points_.first != points_.last
-          points_ = points_ + [points_.first]
+          points_ += [points_.first]
           size_ += 1
         end
         cs_ = ::Geos::CoordinateSequence.new(size_, 3)
@@ -576,7 +534,6 @@ module RGeo
         ::Geos::Utils.create_linear_ring(cs_)
       end
 
-
       def _generate_wkt(geom_)  # :nodoc:
         if @wkt_writer
           @wkt_writer.write(geom_.fg_geom)
@@ -585,7 +542,6 @@ module RGeo
         end
       end
 
-
       def _generate_wkb(geom_)  # :nodoc:
         if @wkb_writer
           @wkb_writer.write(geom_.fg_geom)
@@ -594,8 +550,7 @@ module RGeo
         end
       end
 
-
-      def _write_for_marshal(geom_)  # :nodoc:
+      def _write_for_marshal(geom_) # :nodoc:
         if Utils.ffi_supports_set_output_dimension || !@_has_3d
           unless defined?(@marshal_wkb_writer)
             @marshal_wkb_writer = ::Geos::WkbWriter.new
@@ -607,7 +562,6 @@ module RGeo
         end
       end
 
-
       def _read_for_marshal(str_)  # :nodoc:
         unless defined?(@marshal_wkb_reader)
           @marshal_wkb_reader = ::Geos::WkbReader.new
@@ -615,7 +569,6 @@ module RGeo
         @marshal_wkb_reader.read(str_)
       end
 
-
       def _write_for_psych(geom_)  # :nodoc:
         if Utils.ffi_supports_set_output_dimension || !@_has_3d
           unless defined?(@psych_wkt_writer)
@@ -628,18 +581,12 @@ module RGeo
         end
       end
 
-
-      def _read_for_psych(str_)  # :nodoc:
+      def _read_for_psych(str_) # :nodoc:
         unless defined?(@psych_wkt_reader)
           @psych_wkt_reader = ::Geos::WktReader.new
         end
         @psych_wkt_reader.read(str_)
       end
-
-
     end
-
-
   end
-
 end