rgeo 3.0.0.pre.rc.3 → 3.0.0

data/lib/rgeo/geos/ffi_feature_methods.rb

@@ -13,6 +13,8 @@ module RGeo
     module FFIGeometryMethods # :nodoc:
       include Feature::Instance
 
+      attr_reader :factory, :fg_geom, :_klasses
+
       def initialize(factory, fg_geom, klasses)
         @factory = factory
         @fg_geom = fg_geom
@@ -56,11 +58,6 @@ module RGeo
         @_klasses = nil
       end
 
-      attr_reader :factory
-      attr_reader :fg_geom
-
-      attr_reader :_klasses # :nodoc:
-
       def initialize_copy(orig)
         @factory = orig.factory
         @fg_geom = orig.fg_geom.clone
@@ -94,9 +91,7 @@ module RGeo
       end
 
       def prepare!
-        if @_fg_prep.is_a?(Integer)
-          @_fg_prep = ::Geos::PreparedGeometry.new(@fg_geom)
-        end
+        @_fg_prep = ::Geos::PreparedGeometry.new(@fg_geom) if @_fg_prep.is_a?(Integer)
         self
       end
 
@@ -149,20 +144,21 @@ module RGeo
 
       # (see RGeo::ImplHelper::ValidityCheck#make_valid)
       # Only available since GEOS 3.8+
-      def make_valid
-        @factory.wrap_fg_geom(@fg_geom.make_valid, nil)
-      rescue ::Geos::GEOSException
-        raise Error::UnsupportedOperation
-      end if ::Geos::FFIGeos.respond_to?(:GEOSMakeValid_r)
+      if ::Geos::FFIGeos.respond_to?(:GEOSMakeValid_r)
+        def make_valid
+          @factory.wrap_fg_geom(@fg_geom.make_valid, nil)
+        rescue ::Geos::GEOSException
+          raise Error::UnsupportedOperation
+        end
+      end
 
       def equals?(rhs)
         return false unless rhs.is_a?(RGeo::Feature::Instance)
         fg = factory.convert_to_fg_geometry(rhs)
-        if !fg
-          false
+
         # GEOS has a bug where empty geometries are not spatially equal
         # to each other. Work around this case first.
-        elsif fg.empty? && @fg_geom.empty?
+        if fg.empty? && @fg_geom.empty?
           true
         else
           @fg_geom.eql?(fg)
@@ -172,83 +168,55 @@ module RGeo
 
       def disjoint?(rhs)
         fg = factory.convert_to_fg_geometry(rhs)
-        if fg
-          prep = request_prepared if Utils.ffi_supports_prepared_level_2
-          prep ? prep.disjoint?(fg) : @fg_geom.disjoint?(fg)
-        else
-          false
-        end
+        prep = request_prepared if Utils.ffi_supports_prepared_level_2
+        prep ? prep.disjoint?(fg) : @fg_geom.disjoint?(fg)
       end
 
       def intersects?(rhs)
         fg = factory.convert_to_fg_geometry(rhs)
-        if fg
-          prep = request_prepared if Utils.ffi_supports_prepared_level_1
-          prep ? prep.intersects?(fg) : @fg_geom.intersects?(fg)
-        else
-          false
-        end
+        prep = request_prepared if Utils.ffi_supports_prepared_level_1
+        prep ? prep.intersects?(fg) : @fg_geom.intersects?(fg)
       end
 
       def touches?(rhs)
         fg = factory.convert_to_fg_geometry(rhs)
-        if fg
-          prep = request_prepared if Utils.ffi_supports_prepared_level_2
-          prep ? prep.touches?(fg) : @fg_geom.touches?(fg)
-        else
-          false
-        end
+        prep = request_prepared if Utils.ffi_supports_prepared_level_2
+        prep ? prep.touches?(fg) : @fg_geom.touches?(fg)
       end
 
       def crosses?(rhs)
         fg = factory.convert_to_fg_geometry(rhs)
-        if fg
-          prep = request_prepared if Utils.ffi_supports_prepared_level_2
-          prep ? prep.crosses?(fg) : @fg_geom.crosses?(fg)
-        else
-          false
-        end
+        prep = request_prepared if Utils.ffi_supports_prepared_level_2
+        prep ? prep.crosses?(fg) : @fg_geom.crosses?(fg)
       end
 
       def within?(rhs)
         fg = factory.convert_to_fg_geometry(rhs)
-        if fg
-          prep = request_prepared if Utils.ffi_supports_prepared_level_2
-          prep ? prep.within?(fg) : @fg_geom.within?(fg)
-        else
-          false
-        end
+        prep = request_prepared if Utils.ffi_supports_prepared_level_2
+        prep ? prep.within?(fg) : @fg_geom.within?(fg)
       end
 
       def contains?(rhs)
         fg = factory.convert_to_fg_geometry(rhs)
-        if fg
-          prep = request_prepared if Utils.ffi_supports_prepared_level_1
-          prep ? prep.contains?(fg) : @fg_geom.contains?(fg)
-        else
-          false
-        end
+        prep = request_prepared if Utils.ffi_supports_prepared_level_1
+        prep ? prep.contains?(fg) : @fg_geom.contains?(fg)
       end
 
       def overlaps?(rhs)
         fg = factory.convert_to_fg_geometry(rhs)
-        if fg
-          prep = request_prepared if Utils.ffi_supports_prepared_level_2
-          prep ? prep.overlaps?(fg) : @fg_geom.overlaps?(fg)
-        else
-          false
-        end
+        prep = request_prepared if Utils.ffi_supports_prepared_level_2
+        prep ? prep.overlaps?(fg) : @fg_geom.overlaps?(fg)
       end
 
       def relate?(rhs, pattern)
         fg = factory.convert_to_fg_geometry(rhs)
-        fg ? @fg_geom.relate_pattern(fg, pattern) : nil
+        @fg_geom.relate_pattern(fg, pattern)
       end
       alias relate relate? # DEPRECATED
 
       def distance(rhs)
         fg = factory.convert_to_fg_geometry(rhs)
-        fg ? @fg_geom.distance(fg) : nil
+        @fg_geom.distance(fg)
       end
 
       def buffer(distance)
@@ -261,14 +229,14 @@ module RGeo
 
       def intersection(rhs)
         fg = factory.convert_to_fg_geometry(rhs)
-        fg ? @factory.wrap_fg_geom(@fg_geom.intersection(fg), nil) : nil
+        @factory.wrap_fg_geom(@fg_geom.intersection(fg), nil)
       end
 
       alias * intersection
 
       def union(rhs)
         fg = factory.convert_to_fg_geometry(rhs)
-        fg ? @factory.wrap_fg_geom(@fg_geom.union(fg), nil) : nil
+        @factory.wrap_fg_geom(@fg_geom.union(fg), nil)
       end
 
       alias + union
@@ -280,18 +248,18 @@ module RGeo
 
       def difference(rhs)
         fg = factory.convert_to_fg_geometry(rhs)
-        fg ? @factory.wrap_fg_geom(@fg_geom.difference(fg), nil) : nil
+        @factory.wrap_fg_geom(@fg_geom.difference(fg), nil)
       end
 
       alias - difference
 
       def sym_difference(rhs)
         fg = factory.convert_to_fg_geometry(rhs)
-        fg ? @factory.wrap_fg_geom(@fg_geom.sym_difference(fg), nil) : nil
+        @factory.wrap_fg_geom(@fg_geom.sym_difference(fg), nil)
       end
 
-      def eql?(rhs)
-        rep_equals?(rhs)
+      def eql?(other)
+        rep_equals?(other)
       end
 
       def detach_fg_geom
@@ -343,7 +311,7 @@ module RGeo
       end
 
       def rep_equals?(rhs)
-        rhs.class == self.class && rhs.factory.eql?(@factory) &&
+        rhs.instance_of?(self.class) && rhs.factory.eql?(@factory) &&
           Utils.ffi_coord_seqs_equal?(rhs.fg_geom.coord_seq, @fg_geom.coord_seq, @factory._has_3d)
       end
 
@@ -372,14 +340,15 @@ module RGeo
         @fg_geom.num_points
       end
 
-      def point_n(n)
-        if n >= 0 && n < @fg_geom.num_points
-          coord_seq = @fg_geom.coord_seq
-          x = coord_seq.get_x(n)
-          y = coord_seq.get_y(n)
-          extra = @factory._has_3d ? [coord_seq.get_z(n)] : []
-          @factory.point(x, y, *extra)
-        end
+      def point_n(idx)
+        return unless idx >= 0 && idx < @fg_geom.num_points
+
+        coord_seq = @fg_geom.coord_seq
+        x = coord_seq.get_x(idx)
+        y = coord_seq.get_y(idx)
+        extra = @factory._has_3d ? [coord_seq.get_z(idx)] : []
+
+        @factory.point(x, y, *extra)
       end
 
       def start_point
@@ -410,7 +379,7 @@ module RGeo
       end
 
       def rep_equals?(rhs)
-        rhs.class == self.class && rhs.factory.eql?(@factory) &&
+        rhs.instance_of?(self.class) && rhs.factory.eql?(@factory) &&
           Utils.ffi_coord_seqs_equal?(rhs.fg_geom.coord_seq, @fg_geom.coord_seq, @factory._has_3d)
       end
 
@@ -464,10 +433,10 @@ module RGeo
         @fg_geom.num_interior_rings
       end
 
-      def interior_ring_n(n)
-        if n >= 0 && n < @fg_geom.num_interior_rings
-          @factory.wrap_fg_geom(@fg_geom.interior_ring_n(n), FFILinearRingImpl)
-        end
+      def interior_ring_n(idx)
+        return unless idx >= 0 && idx < @fg_geom.num_interior_rings
+
+        @factory.wrap_fg_geom(@fg_geom.interior_ring_n(idx), FFILinearRingImpl)
       end
 
       def interior_rings
@@ -477,7 +446,7 @@ module RGeo
       end
 
       def rep_equals?(rhs)
-        if rhs.class == self.class && rhs.factory.eql?(@factory) &&
+        if rhs.instance_of?(self.class) && rhs.factory.eql?(@factory) &&
           rhs.exterior_ring.rep_equals?(exterior_ring)
           sn = @fg_geom.num_interior_rings
           rn = rhs.num_interior_rings
@@ -493,8 +462,10 @@ module RGeo
 
       def hash
         @hash ||= begin
-          hash = Utils.ffi_coord_seq_hash(@fg_geom.exterior_ring.coord_seq,
-            [@factory, geometry_type].hash)
+          hash = Utils.ffi_coord_seq_hash(
+            @fg_geom.exterior_ring.coord_seq,
+            [@factory, geometry_type].hash
+          )
           @fg_geom.interior_rings.inject(hash) do |h, r|
             Utils.ffi_coord_seq_hash(r.coord_seq, h)
           end
@@ -512,7 +483,7 @@ module RGeo
       end
 
       def rep_equals?(rhs)
-        if rhs.class == self.class && rhs.factory.eql?(@factory)
+        if rhs.instance_of?(self.class) && rhs.factory.eql?(@factory)
           size = @fg_geom.num_geometries
           if size == rhs.num_geometries
             size.times do |n|
@@ -529,19 +500,24 @@ module RGeo
       end
       alias size num_geometries
 
-      def geometry_n(n)
-        if n >= 0 && n < @fg_geom.num_geometries
-          @factory.wrap_fg_geom(@fg_geom.get_geometry_n(n),
-            @_klasses ? @_klasses[n] : nil)
-        end
+      def geometry_n(idx)
+        return unless idx >= 0 && idx < @fg_geom.num_geometries
+
+        @factory.wrap_fg_geom(
+          @fg_geom.get_geometry_n(idx),
+          @_klasses ? @_klasses[idx] : nil
+        )
       end
 
-      def [](n)
-        n += @fg_geom.num_geometries if n < 0
-        if n >= 0 && n < @fg_geom.num_geometries
-          @factory.wrap_fg_geom(@fg_geom.get_geometry_n(n),
-            @_klasses ? @_klasses[n] : nil)
-        end
+      def [](idx)
+        idx += @fg_geom.num_geometries if idx < 0
+
+        return unless idx >= 0 && idx < @fg_geom.num_geometries
+
+        @factory.wrap_fg_geom(
+          @fg_geom.get_geometry_n(idx),
+          @_klasses ? @_klasses[idx] : nil
+        )
       end
 
       def hash
@@ -551,8 +527,7 @@ module RGeo
       def each
         if block_given?
           @fg_geom.num_geometries.times do |n|
-            yield @factory.wrap_fg_geom(@fg_geom.get_geometry_n(n),
-              @_klasses ? @_klasses[n] : nil)
+            yield @factory.wrap_fg_geom(@fg_geom.get_geometry_n(n), @_klasses ? @_klasses[n] : nil)
           end
           self
         else

data/lib/rgeo/geos/interface.rb

@@ -62,13 +62,12 @@ module RGeo
 
       def version
         unless defined?(@version)
-          if RGeo::Geos::CAPI_SUPPORTED
-            @version = RGeo::Geos::CAPIFactory._geos_version.freeze
-          elsif RGeo::Geos::FFI_SUPPORTED
-            @version = ::Geos::FFIGeos.GEOSversion.sub(/-CAPI-.*$/, "").freeze
-          else
-            @version = nil
-          end
+          @version =
+            if RGeo::Geos::CAPI_SUPPORTED
+              RGeo::Geos::CAPIFactory._geos_version.freeze
+            elsif RGeo::Geos::FFI_SUPPORTED
+              ::Geos::FFIGeos.GEOSversion.sub(/-CAPI-.*$/, "").freeze
+            end
         end
         @version
       end
@@ -163,15 +162,16 @@ module RGeo
       #   never automatically generates a prepared geometry (unless you
       #   generate one explicitly using the <tt>prepare!</tt> method).
       def factory(opts = {})
-        if supported?
-          native_interface = opts[:native_interface] || Geos.preferred_native_interface
-          if opts[:has_z_coordinate] && opts[:has_m_coordinate]
-            ZMFactory.new(opts)
-          elsif native_interface == :ffi
-            FFIFactory.new(opts)
-          else
-            CAPIFactory.create(opts)
-          end
+        return unless supported?
+
+        native_interface = opts[:native_interface] || Geos.preferred_native_interface
+
+        if opts[:has_z_coordinate] && opts[:has_m_coordinate]
+          ZMFactory.new(opts)
+        elsif native_interface == :ffi
+          FFIFactory.new(opts)
+        else
+          CAPIFactory.create(opts)
         end
       end
     end

data/lib/rgeo/geos/utils.rb

@@ -49,9 +49,9 @@ module RGeo
           result
         end
 
-        def ffi_coord_seq_hash(cs, hash = 0)
-          (0...cs.length).inject(hash) do |h, i|
-            [hash, cs.get_x(i), cs.get_y(i), cs.get_z(i)].hash
+        def ffi_coord_seq_hash(coord_seq, init_hash = 0)
+          (0...coord_seq.length).inject(init_hash) do |hash, i|
+            [hash, coord_seq.get_x(i), coord_seq.get_y(i), coord_seq.get_z(i)].hash
           end
         end
 

data/lib/rgeo/geos/zm_factory.rb

@@ -9,7 +9,6 @@
 module RGeo
   module Geos
     # A factory for Geos that handles both Z and M.
-
     class ZMFactory
       include Feature::Factory::Instance
       include ImplHelper::Utils
@@ -60,33 +59,37 @@ module RGeo
         end
 
         wkt_generator = opts[:wkt_generator]
-        case wkt_generator
-        when Hash
-          @wkt_generator = WKRep::WKTGenerator.new(wkt_generator)
-        else
-          @wkt_generator = WKRep::WKTGenerator.new(convert_case: :upper)
-        end
+        @wkt_generator =
+          case wkt_generator
+          when Hash
+            WKRep::WKTGenerator.new(wkt_generator)
+          else
+            WKRep::WKTGenerator.new(convert_case: :upper)
+          end
         wkb_generator = opts[:wkb_generator]
-        case wkb_generator
-        when Hash
-          @wkb_generator = WKRep::WKBGenerator.new(wkb_generator)
-        else
-          @wkb_generator = WKRep::WKBGenerator.new
-        end
+        @wkb_generator =
+          case wkb_generator
+          when Hash
+            WKRep::WKBGenerator.new(wkb_generator)
+          else
+            WKRep::WKBGenerator.new
+          end
         wkt_parser = opts[:wkt_parser]
-        case wkt_parser
-        when Hash
-          @wkt_parser = WKRep::WKTParser.new(self, wkt_parser)
-        else
-          @wkt_parser = WKRep::WKTParser.new(self)
-        end
+        @wkt_parser =
+          case wkt_parser
+          when Hash
+            WKRep::WKTParser.new(self, wkt_parser)
+          else
+            WKRep::WKTParser.new(self)
+          end
         wkb_parser = opts[:wkb_parser]
-        case wkb_parser
-        when Hash
-          @wkb_parser = WKRep::WKBParser.new(self, wkb_parser)
-        else
-          @wkb_parser = WKRep::WKBParser.new(self)
-        end
+        @wkb_parser =
+          case wkb_parser
+          when Hash
+            WKRep::WKBParser.new(self, wkb_parser)
+          else
+            WKRep::WKBParser.new(self)
+          end
       end
 
       # Marshal support
@@ -108,11 +111,9 @@ module RGeo
       end
 
       def marshal_load(data) # :nodoc:
-        if (coord_sys_data = data["cs"])
-          coord_sys = CoordSys::CONFIG.default_coord_sys_class.create_from_wkt(coord_sys_data)
-        else
-          coord_sys = nil
-        end
+        cs_class = CoordSys::CONFIG.default_coord_sys_class
+        coord_sys = data["cs"]&.then { |cs| cs_class.create_from_wkt(cs) }
+
         initialize(
           native_interface: (data["nffi"] ? :ffi : :capi),
           has_z_coordinate: data["hasz"],
@@ -139,17 +140,16 @@ module RGeo
         coder["wkb_parser"] = @wkb_parser.properties
         coder["auto_prepare"] = @zfactory.property(:auto_prepare).to_s
         coder["native_interface"] = @zfactory.is_a?(FFIFactory) ? "ffi" : "capi"
-        if (coord_sys = @zfactory.coord_sys)
-          coder["coord_sys"] = coord_sys.to_wkt
-        end
+
+        return unless (coord_sys = @zfactory.coord_sys)
+
+        coder["coord_sys"] = coord_sys.to_wkt
       end
 
       def init_with(coder) # :nodoc:
-        if (coord_sys_data = coder["cs"])
-          coord_sys = CoordSys::CONFIG.default_coord_sys_class.create_from_wkt(coord_sys_data.to_s)
-        else
-          coord_sys = nil
-        end
+        cs_class = CoordSys::CONFIG.default_coord_sys_class
+        coord_sys = coder["cs"]&.then { |cs| cs_class.create_from_wkt(cs) }
+
         initialize(
           native_interface: coder["native_interface"] == "ffi" ? :ffi : :capi,
           has_z_coordinate: coder["has_z_coordinate"],
@@ -192,8 +192,8 @@ module RGeo
 
       # Factory equivalence test.
 
-      def eql?(rhs)
-        rhs.is_a?(ZMFactory) && rhs.z_factory == @zfactory
+      def eql?(other)
+        other.is_a?(ZMFactory) && other.z_factory == @zfactory
       end
       alias == eql?
 
@@ -227,7 +227,11 @@ module RGeo
       # See RGeo::Feature::Factory#point
 
       def point(x, y, z = 0, m = 0)
-        create_feature(ZMPointImpl, @zfactory.point(x, y, z), @mfactory.point(x, y, m))
+        create_feature(
+          ZMPointImpl,
+          @zfactory.point(x, y, z),
+          @mfactory.point(x, y, m)
+        )
       end
 
       # See RGeo::Feature::Factory#line_string
@@ -251,7 +255,11 @@ module RGeo
       # See RGeo::Feature::Factory#polygon
 
       def polygon(outer_ring, inner_rings = nil)
-        create_feature(ZMPolygonImpl, @zfactory.polygon(outer_ring, inner_rings), @mfactory.polygon(outer_ring, inner_rings))
+        create_feature(
+          ZMPolygonImpl,
+          @zfactory.polygon(outer_ring, inner_rings),
+          @mfactory.polygon(outer_ring, inner_rings)
+        )
       end
 
       # See RGeo::Feature::Factory#collection

data/lib/rgeo/geos/zm_feature_methods.rb

@@ -159,12 +159,19 @@ module RGeo
 
       def sym_difference(rhs)
         rhs = RGeo::Feature.cast(rhs, self)
-        @factory.create_feature(nil, @zgeometry.sym_difference(rhs.z_geometry), @mgeometry.sym_difference(rhs.m_geometry))
+        @factory.create_feature(
+          nil,
+          @zgeometry.sym_difference(rhs.z_geometry),
+          @mgeometry.sym_difference(rhs.m_geometry)
+        )
       end
 
       def rep_equals?(rhs)
         rhs = RGeo::Feature.cast(rhs, self)
-        rhs.is_a?(self.class) && @factory.eql?(rhs.factory) && @zgeometry.rep_equals?(rhs.z_geometry) && @mgeometry.rep_equals?(rhs.m_geometry)
+        rhs.is_a?(self.class) &&
+          @factory.eql?(rhs.factory) &&
+          @zgeometry.rep_equals?(rhs.z_geometry) &&
+          @mgeometry.rep_equals?(rhs.m_geometry)
       end
 
       alias eql? rep_equals?
@@ -250,8 +257,8 @@ module RGeo
         @zgeometry.num_points
       end
 
-      def point_n(n)
-        @factory.create_feature(ZMPointImpl, @zgeometry.point_n(n), @mgeometry.point_n(n))
+      def point_n(idx)
+        @factory.create_feature(ZMPointImpl, @zgeometry.point_n(idx), @mgeometry.point_n(idx))
       end
 
       def points
@@ -290,8 +297,8 @@ module RGeo
         @zgeometry.num_interior_rings
       end
 
-      def interior_ring_n(n)
-        @factory.create_feature(ZMLineStringImpl, @zgeometry.interior_ring_n(n), @mgeometry.interior_ring_n(n))
+      def interior_ring_n(idx)
+        @factory.create_feature(ZMLineStringImpl, @zgeometry.interior_ring_n(idx), @mgeometry.interior_ring_n(idx))
       end
 
       def interior_rings
@@ -315,8 +322,8 @@ module RGeo
       end
       alias size num_geometries
 
-      def geometry_n(n)
-        @factory.create_feature(nil, @zgeometry.geometry_n(n), @mgeometry.geometry_n(n))
+      def geometry_n(idx)
+        @factory.create_feature(nil, @zgeometry.geometry_n(idx), @mgeometry.geometry_n(idx))
       end
       alias [] geometry_n
 

data/lib/rgeo/impl_helper/basic_geometry_collection_methods.rb

@@ -27,12 +27,12 @@ module RGeo
         @elements.size
       end
 
-      def geometry_n(n)
-        n < 0 ? nil : @elements[n]
+      def geometry_n(idx)
+        idx < 0 ? nil : @elements[idx]
       end
 
-      def [](n)
-        @elements[n]
+      def [](idx)
+        @elements[idx]
       end
 
       def each(&block)

data/lib/rgeo/impl_helper/basic_geometry_methods.rb

@@ -52,8 +52,7 @@ module RGeo
         @factory = obj.factory
       end
 
-      def init_geometry
-      end
+      def init_geometry; end
     end
   end
 end