rgeo 3.0.0.pre.rc.2 → 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
 
@@ -125,20 +120,10 @@ module RGeo
         @fg_geom.empty?
       end
 
-      def is_empty?
-        warn "The is_empty? method is deprecated, please use the empty? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"]
-        empty?
-      end
-
       def simple?
         @fg_geom.simple?
       end
 
-      def is_simple?
-        warn "The is_simple? method is deprecated, please use the simple? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"]
-        simple?
-      end
-
       def is_3d?
         factory.property(:has_z_coordinate)
       end
@@ -159,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)
@@ -182,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)
@@ -271,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
@@ -290,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
@@ -353,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
 
@@ -382,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
@@ -415,22 +374,12 @@ module RGeo
         @fg_geom.closed?
       end
 
-      def is_closed?
-        warn "The is_closed? method is deprecated, please use the closed? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"]
-        closed?
-      end
-
       def ring?
         @fg_geom.ring?
       end
 
-      def is_ring?
-        warn "The is_ring? method is deprecated, please use the ring? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"]
-        ring?
-      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
 
@@ -484,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
@@ -497,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
@@ -513,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
@@ -532,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|
@@ -549,35 +500,34 @@ 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
-        @hash ||= begin
-          hash = [@factory, geometry_type].hash
-          (0...num_geometries).inject(hash) do |h, i|
-            (1_664_525 * h + geometry_n(i).hash).hash
-          end
-        end
+        @hash ||= [@factory, geometry_type, *(0...num_geometries).map { |i| geometry_n(i) }].hash
       end
 
       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
@@ -615,11 +565,6 @@ module RGeo
         true
       end
 
-      def is_closed?
-        warn "The is_closed? method is deprecated, please use the closed? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"]
-        closed?
-      end
-
       def coordinates
         each.map(&:coordinates)
       end

data/lib/rgeo/geos/interface.rb

@@ -38,11 +38,6 @@ module RGeo
           ZMGeometryMethods === object && CAPIGeometryMethods === object.z_geometry)
       end
 
-      def is_capi_geos?(object)
-        warn "The is_capi_geos? method is deprecated, please use the capi_geos? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"]
-        capi_geos?(object)
-      end
-
       # Returns true if the given feature is an FFI GEOS feature, or if
       # the given factory is an FFI GEOS factory.
 
@@ -53,11 +48,6 @@ module RGeo
           ZMGeometryMethods === object && FFIGeometryMethods === object.z_geometry)
       end
 
-      def is_ffi_geos?(object)
-        warn "The is_ffi_geos? method is deprecated, please use the ffi_geos? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"]
-        ffi_geos?(object)
-      end
-
       # Returns true if the given feature is a GEOS feature, or if the given
       # factory is a GEOS factory. Does not distinguish between CAPI and FFI.
 
@@ -67,23 +57,17 @@ module RGeo
           ZMFactory === object || ZMGeometryMethods === object
       end
 
-      def is_geos?(object)
-        warn "The is_geos? method is deprecated, please use the geos? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"]
-        geos?(object)
-      end
-
       # Returns the GEOS library version as a string of the format "x.y.z".
       # Returns nil if GEOS is not available.
 
       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
@@ -127,14 +111,14 @@ module RGeo
       # [<tt>:srid</tt>]
       #   Set the SRID returned by geometries created by this factory.
       #   Default is 0.
-      # [<tt>:proj4</tt>]
-      #   The coordinate system in Proj4 format, either as a
-      #   CoordSys::Proj4 object or as a string or hash representing the
-      #   proj4 format. Optional.
       # [<tt>:coord_sys</tt>]
       #   The coordinate system in OGC form, either as a subclass of
       #   CoordSys::CS::CoordinateSystem, or as a string in WKT format.
-      #   Optional.
+      #   Optional. If not provided, but <tt>:srid</tt> is, a coord_sys
+      #   will be created using the CS::CONFIG.default_coord_sys_class.
+      #  [<tt>:coord_sys_class</tt>]
+      #    The coordinate system implementation to use if you do not want to
+      #    use the CS::CONFIG.default_coord_sys_class. Optional.
       # [<tt>:has_z_coordinate</tt>]
       #   Support <tt>z_coordinate</tt>. Default is false.
       # [<tt>:has_m_coordinate</tt>]
@@ -178,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